Orchestrator 8B

from openai import OpenAI

# Initialize the OpenAI client with Qubrid base URL
client = OpenAI(
  base_url="https://platform.qubrid.com/v1",
  api_key="QUBRID_API_KEY",
)

# Create a streaming chat completion
stream = client.chat.completions.create(
  model="nvidia/Orchestrator-8B",
  messages=[
    {
      "role": "user",
      "content": "Explain quantum computing in simple terms"
    }
  ],
  max_tokens=4096,
  temperature=0.4,
  top_p=1,
  stream=True
)

# If stream = False comment this out
for chunk in stream:
  if chunk.choices and chunk.choices[0].delta.content:
      print(chunk.choices[0].delta.content, end="", flush=True)
print("\n")

# If stream = True comment this out
print(stream.choices[0].message.content)

import OpenAI from "openai";

// Initialize the OpenAI client with Qubrid base URL
const client = new OpenAI({
  baseURL: "https://platform.qubrid.com/v1",
  apiKey: "QUBRID_API_KEY",
});

// Create a streaming chat completion
const stream = await client.chat.completions.create({
  model: "nvidia/Orchestrator-8B",
  messages: [
    {
      role: "user",
      content: "Explain quantum computing in simple terms",
    },
  ],
  max_tokens: 4096,
  temperature: 0.4,
  top_p: 1,
  stream: true,
});

// If stream = false comment this out
for await (const chunk of stream) {
  if (chunk.choices[0]?.delta?.content) {
    process.stdout.write(chunk.choices[0].delta.content);
  }
}
console.log("\n");

// If stream = true comment this out
console.log(stream.choices[0].message.content);

package main

import (
	"bufio"
	"bytes"
	"encoding/json"
	"fmt"
	"net/http"
)

func main() {
	url := "https://platform.qubrid.com/v1/chat/completions"

	data := map[string]interface{}{
		"model": "nvidia/Orchestrator-8B",
		"messages": []map[string]string{
			{
				"role":    "user",
				"content": "Explain quantum computing in simple terms",
			},
		},
		"temperature": 0.4,
		"max_tokens":  4096,
		"stream":      true,
		"top_p":       1,
	}

	jsonData, _ := json.Marshal(data)
	req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
	req.Header.Set("Authorization", "Bearer QUBRID_API_KEY")
	req.Header.Set("Content-Type", "application/json")

	client := &http.Client{}
	res, _ := client.Do(req)
	defer res.Body.Close()

	scanner := bufio.NewScanner(res.Body)
	for scanner.Scan() {
		line := scanner.Text()
		if line != "" {
			fmt.Println(line)
		}
	}
}

curl -X POST "https://platform.qubrid.com/v1/chat/completions" \
  -H "Authorization: Bearer QUBRID_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "model": "nvidia/Orchestrator-8B",
  "messages": [
    {
      "role": "user",
      "content": "Explain quantum computing in simple terms"
    }
  ],
  "temperature": 0.4,
  "max_tokens": 4096,
  "stream": true,
  "top_p": 1
}'

Task: IT Support Ticket Automation Workflow
Agent: Orchestrator-8B

Step 1 — Create Support Ticket
  Tool: ticketing_api.create()
  Inputs: { user_id, issue_description, priority: "medium", timestamp: now() }
  Output: ticket_id, created_at

Step 2 — Confirm Ticket Receipt
  Tool: notification_api.send()
  Inputs: { user_id, message: "Ticket #{ticket_id} created. Tracking started." }
  Output: delivery_status

Step 3 — Poll Ticket Status (every 12 hours)
  Tool: ticketing_api.get_status(ticket_id)
  Condition: IF status == "resolved" → END workflow
             IF status == "open" AND age > 48h → GOTO Step 4
             ELSE → wait 12h and re-poll

Step 4 — Escalate Ticket
  Tool: ticketing_api.escalate(ticket_id)
  Inputs: { reason: "Unresolved after 48h", escalation_level: "L2" }
  Output: escalation_id, assigned_agent

Step 5 — Notify User of Escalation
  Tool: notification_api.send()
  Inputs: { user_id, message: "Your ticket has been escalated to L2 support.
            Expected resolution: 24h. Escalation ID: #{escalation_id}" }

Step 6 — Log Workflow Completion
  Tool: audit_logger.record()
  Inputs: { ticket_id, escalation_id, timestamps, resolution_status }

Workflow complete. All steps are idempotent and safe to retry on failure.

Example: "You are a DevOps automation agent with access to the following tools:
deploy_service(), rollback_version(), check_health(), send_alert().
Always validate service health before and after any deployment action.
Output all decisions as structured JSON."